package com.huangyi;

public class Main {
    public static void main(String[] args) {
        Solution solution = new Solution();

        // 测试用例1：包含正数和负数
        int[] nums1 = {1, -2, -3, 4};
        System.out.println("测试用例1: [1,-2,-3,4]");
        System.out.println("最长子数组长度: " + solution.getMaxLen(nums1)); // 预期输出: 4

        // 测试用例2：包含0
        int[] nums2 = {0, 1, -2, -3, 4};
        System.out.println("\n测试用例2: [0,1,-2,-3,4]");
        System.out.println("最长子数组长度: " + solution.getMaxLen(nums2)); // 预期输出: 4

        // 测试用例3：全是负数
        int[] nums3 = {-1, -2, -3, -4, -5};
        System.out.println("\n测试用例3: [-1,-2,-3,-4,-5]");
        System.out.println("最长子数组长度: " + solution.getMaxLen(nums3)); // 预期输出: 4

        // 测试用例4：多个0分割
        int[] nums4 = {1, 2, 3, 0, -1, -2};
        System.out.println("\n测试用例4: [1,2,3,0,-1,-2]");
        System.out.println("最长子数组长度: " + solution.getMaxLen(nums4)); // 预期输出: 3
    }

    // 乘积为正数的最长子数组长度
    static class Solution {
        public int getMaxLen(int[] nums) {
            int m = nums.length;
            int[] f = new int[m + 1];  // f[i]: 以 nums[i-1] 结尾的乘积为正的最长长度
            int[] g = new int[m + 1];  // g[i]: 以 nums[i-1] 结尾的乘积为负的最长长度

            // 初始化：空数组时两条链长度都是 0
            f[0] = 0;
            g[0] = 0;

            int ret = 0;

            for (int i = 1; i <= m; i++) {
                if (nums[i - 1] > 0) {
                    // 当前元素为正数
                    // f[i] 存储正数链：正数自己可以延长正数链
                    f[i] = f[i - 1] + 1;

                    // g[i] 存储负数链：正数可以延长负数链，但前提是之前存在负数链
                    if (g[i - 1] > 0) {
                        g[i] = g[i - 1] + 1;
                    } else {
                        // 之前不存在负数链，当前正数无法单独形成负数链
                        g[i] = 0;
                    }

                } else if (nums[i - 1] < 0) {
                    // 当前元素为负数
                    // f[i] 存储正数链：负数可以把之前的负数链变成正数链（负负得正）
                    if (g[i - 1] > 0) {
                        f[i] = g[i - 1] + 1;
                    } else {
                        // 之前不存在负数链，当前负数无法形成正数链
                        f[i] = 0;
                    }

                    // g[i] 存储负数链：负数可以把之前的正数链变成负数链，或自己单独成链
                    g[i] = f[i - 1] + 1;

                } else {
                    // 当前元素为 0，乘积为 0 不是正数，两条链都断掉
                    f[i] = 0;
                    g[i] = 0;
                }

                // 更新全局最大值
                ret = Math.max(ret, f[i]);
            }

            return ret;
        }
    }
}